package com.wakaca.disruptordemo;

import java.lang.reflect.Array;
import java.util.concurrent.*;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

public class ReView {

    public static void main(String[] args) throws Exception {
//        ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();

//        CopyOnWriteArrayList<String> cowal = new CopyOnWriteArrayList<>();
//        cowal.add("aaa");

//        AtomicLong count = new AtomicLong(1);
//        boolean flag = count.compareAndSet(0, 2);
//        System.err.println(flag);
//        System.err.println(count.get());

//        Object lock = new Object();
//        Thread A = new Thread(new Runnable() {
//            @Override
//            public void run() {
//                int sum = 0;
//                for(int i=0; i<10; i++) {
//                    sum += i;
//                }
//
////                synchronized (lock) {
////                    try {
////                        lock.wait();    // 等待并释放锁
////                    } catch (InterruptedException e) {
////                        e.printStackTrace();
////                    }
////                }
//
//                LockSupport.park(); // 挂起线程并等待
//                System.err.println("sum: "+sum);
//            }
//        });
//
//        A.start();
//        Thread.sleep(2000);
//
////        synchronized (lock) { // 必须使用 synchronized 先获得锁
////            lock.notify();  // 不释放锁
////        }
//
//        LockSupport.unpark(A);  // 参数表示对那个挂起的线程进行恢复

//        Thread A = new Thread(new Runnable() {
//            @Override
//            public void run() {
//                int sum = 0;
//                for(int i=0; i<10; i++) {
//                    sum += i;
//                }
//                try {
//                    Thread.sleep(4000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                LockSupport.park(); // 后执行
//                System.err.println("sum: "+sum);
//            }
//        });
//
//        A.start();
//        Thread.sleep(2000);
//
//        // 一个unpark,可以抵消过去的一个park或者将来的一个park
//        // 多个unpark,可以抵消过去的多个park
//        // 多个unpark,不可以抵消将来的多个park
//        LockSupport.unpark(A); // 先执行

//        Executors.newCachedThreadPool();  // 不能存储线程，只能立马被创建，因为内部用的是 SynchronousQueue
//        Executors.newFixedThreadPool(10);
//
//        // 线程池数量怎么考量？
//
//        ThreadPoolExecutor pool = new ThreadPoolExecutor(5,
//                Runtime.getRuntime().availableProcessors() * 2,
//                60,
//                TimeUnit.SECONDS,
//                new ArrayBlockingQueue<>(200),
//                new ThreadFactory() {
//                    @Override
//                    public Thread newThread(Runnable r) {
//                        Thread t = new Thread(r);
//                        t.setName("order-thread");
//                        if (t.isDaemon()) {
//                            t.setDaemon(false);
//                        }
//                        if (Thread.NORM_PRIORITY != t.getPriority()) {
//                            t.setPriority(Thread.NORM_PRIORITY);
//                        }
//                        return t;
//                    }
//                },
//                new RejectedExecutionHandler() {
//                    @Override
//                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
//                        // 拒绝策略一般是做一些日志或补偿
//                        System.err.println("拒绝策略：" + r);
//                    }
//                });
//        pool.shutdown();

        ReentrantLock reentrantLock = new ReentrantLock(true);
    }

}
